```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>OSS访问控制策略深度解析 | 技术小馆</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
        }
        .hero-bg {
            background: linear-gradient(135deg, #1e3c72 0%, #2a5298 100%);
        }
        .section-title {
            position: relative;
            padding-bottom: 10px;
            margin-bottom: 30px;
        }
        .section-title:after {
            content: '';
            position: absolute;
            bottom: 0;
            left: 0;
            width: 60px;
            height: 4px;
            background: linear-gradient(90deg, #3b82f6 0%, #10b981 100%);
            border-radius: 2px;
        }
        .code-block {
            background-color: #2d3748;
            border-radius: 8px;
            position: relative;
        }
        .code-header {
            background-color: #1a202c;
            border-top-left-radius: 8px;
            border-top-right-radius: 8px;
            padding: 8px 15px;
            color: #e2e8f0;
            font-size: 0.85rem;
            display: flex;
            align-items: center;
        }
        .code-content {
            padding: 15px;
            overflow-x: auto;
        }
        .copy-btn {
            position: absolute;
            right: 15px;
            top: 10px;
            background-color: #4a5568;
            color: white;
            border: none;
            border-radius: 4px;
            padding: 2px 8px;
            font-size: 0.7rem;
            cursor: pointer;
            transition: all 0.2s;
        }
        .copy-btn:hover {
            background-color: #3b82f6;
        }
        .card {
            transition: transform 0.3s ease, box-shadow 0.3s ease;
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .note {
            border-left: 4px solid #3b82f6;
            background-color: #f8fafc;
        }
        .warning {
            border-left: 4px solid #f59e0b;
            background-color: #fffbeb;
        }
        .important {
            border-left: 4px solid #10b981;
            background-color: #ecfdf5;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero-bg text-white py-20 md:py-32">
        <div class="container mx-auto px-6 max-w-5xl">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-2/3">
                    <h1 class="text-4xl md:text-5xl font-bold leading-tight mb-4" style="font-family: 'Noto Serif SC'">OSS访问控制策略深度解析</h1>
                    <p class="text-xl md:text-2xl opacity-90 mb-8">构建安全可靠的对象存储权限体系</p>
                    <div class="flex flex-wrap gap-4">
                        <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full flex items-center">
                            <i class="fas fa-shield-alt mr-2"></i> 数据安全
                        </span>
                        <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full flex items-center">
                            <i class="fas fa-cloud mr-2"></i> 对象存储
                        </span>
                        <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full flex items-center">
                            <i class="fas fa-lock mr-2"></i> 访问控制
                        </span>
                    </div>
                </div>
                <div class="md:w-1/3 mt-10 md:mt-0 flex justify-center">
                    <div class="w-48 h-48 md:w-64 md:h-64 bg-blue-600 rounded-full flex items-center justify-center opacity-80">
                        <i class="fas fa-cloud text-white text-6xl md:text-8xl"></i>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <div class="container mx-auto px-6 py-12 max-w-5xl">
        <section class="mb-16">
            <p class="text-lg text-gray-600 mb-8 leading-relaxed">
                在当今数字化时代，数据的存储和管理变得至关重要。对象存储服务（OSS）作为一种高效、可扩展的存储解决方案，被广泛应用于各类项目中。然而，随着数据的重要性日益提升，如何确保数据的安全性和可控性成为了关键问题。OSS 访问控制策略正是解决这一问题的核心手段，它包括 Bucket Policy、ACL（访问控制列表）以及 RAM（资源访问管理）权限配置等多个方面。
            </p>
            
            <div class="grid grid-cols-1 md:grid-cols-3 gap-6 mb-12">
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <div class="text-blue-500 text-3xl mb-4">
                        <i class="fas fa-sitemap"></i>
                    </div>
                    <h3 class="font-bold text-xl mb-3">Bucket Policy</h3>
                    <p class="text-gray-600">基于JSON的灵活策略语言，实现细粒度访问控制</p>
                </div>
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <div class="text-green-500 text-3xl mb-4">
                        <i class="fas fa-list-alt"></i>
                    </div>
                    <h3 class="font-bold text-xl mb-3">ACL</h3>
                    <p class="text-gray-600">简单直观的访问控制列表，快速设置基础权限</p>
                </div>
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <div class="text-purple-500 text-3xl mb-4">
                        <i class="fas fa-users-cog"></i>
                    </div>
                    <h3 class="font-bold text-xl mb-3">RAM权限</h3>
                    <p class="text-gray-600">集中管理用户和用户组，实现企业级权限控制</p>
                </div>
            </div>
        </section>

        <!-- Section 1 -->
        <section class="mb-16">
            <h2 class="section-title text-3xl font-bold" style="font-family: 'Noto Serif SC'">一、OSS 访问控制概述</h2>
            <p class="mb-6">
                OSS 的访问控制旨在确保只有授权的用户或应用程序能够访问存储在 OSS 中的数据。通过合理配置访问控制策略，可以精确控制不同用户或角色对 OSS 资源（如 Bucket 和 Object）的访问权限，从而防止数据泄露和非法操作。
            </p>
            
            <div class="grid grid-cols-1 md:grid-cols-2 gap-6 mb-8">
                <div class="bg-white p-6 rounded-xl shadow-sm note">
                    <h3 class="font-bold text-lg mb-3 flex items-center">
                        <i class="fas fa-lightbulb text-blue-500 mr-2"></i> 访问控制的重要性
                    </h3>
                    <p class="text-gray-700">
                        想象一下，一个电商平台的 OSS 存储了大量用户的订单信息、个人资料以及商品图片等敏感数据。如果没有有效的访问控制，任何恶意用户都可能轻易获取这些数据，导致严重的安全事故和用户信任危机。因此，访问控制是保障数据安全、维护企业声誉和用户权益的重要防线。
                    </p>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-sm">
                    <h3 class="font-bold text-lg mb-3 flex items-center">
                        <i class="fas fa-book text-blue-500 mr-2"></i> 访问控制的基本概念
                    </h3>
                    <ul class="space-y-2 text-gray-700">
                        <li class="flex items-start">
                            <i class="fas fa-circle text-xs mt-2 mr-2 text-blue-500"></i>
                            <span><strong>资源</strong>：在 OSS 中，资源主要指 Bucket 和 Object。Bucket 是 OSS 中的存储容器，类似于文件夹；Object 则是存储在 Bucket 中的文件或数据对象。</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-circle text-xs mt-2 mr-2 text-blue-500"></i>
                            <span><strong>主体</strong>：主体是指发起对 OSS 资源访问请求的实体，可以是用户、应用程序或服务账号等。</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-circle text-xs mt-2 mr-2 text-blue-500"></i>
                            <span><strong>权限</strong>：权限定义了主体对资源的操作许可，例如读取、写入、删除等。</span>
                        </li>
                    </ul>
                </div>
            </div>
            
            <!-- Visualization -->
            <div class="bg-white p-6 rounded-xl shadow-sm mb-8">
                <div class="mermaid">
                    graph TD
                        A[访问控制策略] --> B[Bucket Policy]
                        A --> C[ACL]
                        A --> D[RAM权限]
                        B --> E[基于JSON的策略]
                        B --> F[细粒度控制]
                        C --> G[预定义权限]
                        C --> H[简单易用]
                        D --> I[用户/用户组管理]
                        D --> J[企业级权限]
                </div>
            </div>
        </section>

        <!-- Section 2 -->
        <section class="mb-16">
            <h2 class="section-title text-3xl font-bold" style="font-family: 'Noto Serif SC'">二、Bucket Policy</h2>
            <p class="mb-6">
                Bucket Policy 是一种基于 JSON 格式的策略语言，用于定义对 Bucket 及其内部 Object 的访问权限。它提供了一种灵活且强大的方式来控制不同主体对 OSS 资源的访问。
            </p>
            
            <h3 class="font-bold text-xl mb-4 flex items-center">
                <i class="fas fa-code text-blue-500 mr-2"></i> Bucket Policy 的语法结构
            </h3>
            <p class="mb-4">
                Bucket Policy 的基本语法结构如下：
            </p>
            
            <div class="code-block mb-6">
                <div class="code-header">
                    <span>JSON</span>
                    <button class="copy-btn" onclick="copyCode(this)">
                        <i class="fas fa-copy mr-1"></i> 复制
                    </button>
                </div>
                <div class="code-content">
                    <pre class="text-gray-200"><code>{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Effect",
      "Principal": "Principal",
      "Action": "Action",
      "Resource": "Resource"
    }
  ]
}</code></pre>
                </div>
            </div>
            
            <ul class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-8">
                <li class="bg-gray-50 p-4 rounded-lg">
                    <h4 class="font-bold text-blue-600 mb-2">Version</h4>
                    <p class="text-gray-700">策略版本号，目前固定为 "1"。</p>
                </li>
                <li class="bg-gray-50 p-4 rounded-lg">
                    <h4 class="font-bold text-blue-600 mb-2">Statement</h4>
                    <p class="text-gray-700">一个数组，包含一条或多条策略语句，每条语句定义了一个具体的访问控制规则。</p>
                </li>
                <li class="bg-gray-50 p-4 rounded-lg">
                    <h4 class="font-bold text-blue-600 mb-2">Effect</h4>
                    <p class="text-gray-700">指定策略的生效方式，取值为 "Allow"（允许）或 "Deny"（拒绝）。</p>
                </li>
                <li class="bg-gray-50 p-4 rounded-lg">
                    <h4 class="font-bold text-blue-600 mb-2">Principal</h4>
                    <p class="text-gray-700">指定受该策略影响的主体，可以是具体的用户 ID、用户组或通配符（如 "*" 表示所有主体）。</p>
                </li>
                <li class="bg-gray-50 p-4 rounded-lg">
                    <h4 class="font-bold text-blue-600 mb-2">Action</h4>
                    <p class="text-gray-700">指定主体被允许或拒绝执行的操作，例如 "oss:GetObject"（读取 Object）、"oss:PutObject"（写入 Object）等。</p>
                </li>
                <li class="bg-gray-50 p-4 rounded-lg">
                    <h4 class="font-bold text-blue-600 mb-2">Resource</h4>
                    <p class="text-gray-700">指定受该策略影响的资源，格式为 "arn:acs:oss:{region}:{account-id}:{bucket-name}/_"，其中"{region}"为地域，"{account-id}"为账号 ID，"{bucket-name}"为 Bucket 名称，"_" 表示该 Bucket 下的所有 Object。</p>
                </li>
            </ul>
            
            <h3 class="font-bold text-xl mb-4 flex items-center">
                <i class="fas fa-laptop-code text-blue-500 mr-2"></i> 实际案例分析
            </h3>
            <p class="mb-4">
                假设我们有一个名为 "ts" 的 Bucket，用于存储公司内部的文档资料。我们希望允许公司内部的特定用户组 "employees" 能够读取和写入该 Bucket 中的所有文件，但不允许外部用户访问。可以通过以下 Bucket Policy 来实现：
            </p>
            
            <div class="code-block mb-6">
                <div class="code-header">
                    <span>JSON</span>
                    <button class="copy-btn" onclick="copyCode(this)">
                        <i class="fas fa-copy mr-1"></i> 复制
                    </button>
                </div>
                <div class="code-content">
                    <pre class="text-gray-200"><code>{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "RAM": "acs:ram::{account-id}:group/employees"
      },
      "Action": [
        "oss:GetObject",
        "oss:PutObject"
      ],
      "Resource": "arn:acs:oss:{region}:{account-id}:ts/*"
    },
    {
      "Effect": "Deny",
      "Principal": {
        "RAM": "*"
      },
      "Action": [
        "oss:GetObject",
        "oss:PutObject"
      ],
      "Resource": "arn:acs:oss:{region}:{account-id}:ts/*",
      "Condition": {
        "StringNotEquals": {
          "acs:PrincipalOrgID": "{company-org-id}"
        }
      }
    }
  ]
}</code></pre>
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-sm important">
                <p class="text-gray-700">
                    在这个例子中，第一条策略语句允许 "employees" 用户组对 "ts" Bucket 下的所有 Object 进行读取和写入操作。第二条策略语句则拒绝所有不属于公司组织 ID（"{company-org-id}"）的主体访问该 Bucket，从而确保了外部用户无法访问。
                </p>
            </div>
        </section>

        <!-- Section 3 -->
        <section class="mb-16">
            <h2 class="section-title text-3xl font-bold" style="font-family: 'Noto Serif SC'">三、ACL（访问控制列表）</h2>
            <p class="mb-6">
                ACL 是一种简单直观的访问控制方式，它通过为每个 OSS 资源（Bucket 或 Object）关联一个访问控制列表，来定义不同用户或用户组对该资源的访问权限。
            </p>
            
            <h3 class="font-bold text-xl mb-4 flex items-center">
                <i class="fas fa-list text-blue-500 mr-2"></i> ACL 的权限类型
            </h3>
            <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-8">
                <div class="bg-white p-5 rounded-lg shadow-sm">
                    <h4 class="font-bold text-lg text-blue-600 mb-2">private</h4>
                    <p class="text-gray-700">私有访问权限，只有 Bucket 的所有者或被授权的用户可以访问。</p>
                </div>
                <div class="bg-white p-5 rounded-lg shadow-sm">
                    <h4 class="font-bold text-lg text-blue-600 mb-2">public-read</h4>
                    <p class="text-gray-700">公共读权限，任何人都可以读取 Bucket 或 Object，但只有所有者可以写入和删除。</p>
                </div>
                <div class="bg-white p-5 rounded-lg shadow-sm warning">
                    <h4 class="font-bold text-lg text-orange-600 mb-2">public-read-write</h4>
                    <p class="text-gray-700">公共读写权限，任何人都可以读取、写入和删除 Bucket 或 Object。这种权限类型应谨慎使用，因为它可能导致数据安全风险。</p>
                </div>
            </div>
            
            <h3 class="font-bold text-xl mb-4 flex items-center">
                <i class="fas fa-terminal text-blue-500 mr-2"></i> 设置和管理 ACL
            </h3>
            <p class="mb-4">
                在 Java 代码中，可以使用 OSS Java SDK 来设置和管理 ACL。以下是一个示例代码，展示了如何将一个 Bucket 的 ACL 设置为 "public-read"：
            </p>
            
            <div class="code-block mb-6">
                <div class="code-header">
                    <span>Java</span>
                    <button class="copy-btn" onclick="copyCode(this)">
                        <i class="fas fa-copy mr-1"></i> 复制
                    </button>
                </div>
                <div class="code-content">
                    <pre class="text-gray-200"><code>import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.model.SetBucketAclRequest;
import com.aliyun.oss.model.CannedAccessControlList;

public class OssAclDemo {
    public static void main(String[] args) {
        // 初始化OSSClient
        String endpoint = "https://oss-{region}.aliyuncs.com";
        String accessKeyId = "your-access-key-id";
        String accessKeySecret = "your-access-key-secret";
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        
        try {
            // 设置Bucket的ACL为public-read
            String bucketName = "ts";
            SetBucketAclRequest setBucketAclRequest = 
                new SetBucketAclRequest(bucketName, CannedAccessControlList.PublicRead);
            ossClient.setBucketAcl(setBucketAclRequest);
            System.out.println("Bucket ACL set to public-read successfully.");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭OSSClient
            ossClient.shutdown();
        }
    }
}</code></pre>
                </div>
            </div>
            
            <h3 class="font-bold text-xl mb-4 flex items-center">
                <i class="fas fa-balance-scale text-blue-500 mr-2"></i> ACL 与 Bucket Policy 的比较
            </h3>
            <div class="overflow-x-auto mb-8">
                <table class="min-w-full bg-white rounded-lg overflow-hidden">
                    <thead class="bg-gray-100">
                        <tr>
                            <th class="py-3 px-4 text-left font-semibold text-gray-700">对比项</th>
                            <th class="py-3 px-4 text-left font-semibold text-gray-700">ACL</th>
                            <th class="py-3 px-4 text-left font-semibold text-gray-700">Bucket Policy</th>
                        </tr>
                    </thead>
                    <tbody class="divide-y divide-gray-200">
                        <tr>
                            <td class="py-3 px-4 text-gray-700 font-medium">功能复杂度</td>
                            <td class="py-3 px-4 text-gray-600">相对简单，只提供了几种预定义的权限类型</td>
                            <td class="py-3 px-4 text-gray-600">更加灵活和强大，可以定义复杂的访问控制规则</td>
                        </tr>
                        <tr>
                            <td class="py-3 px-4 text-gray-700 font-medium">继承关系</td>
                            <td class="py-3 px-4 text-gray-600">Object 的 ACL 可以继承 Bucket 的 ACL</td>
                            <td class="py-3 px-4 text-gray-600">统一应用于 Bucket 及其内部的所有 Object</td>
                        </tr>
                        <tr>
                            <td class="py-3 px-4 text-gray-700 font-medium">适用场景</td>
                            <td class="py-3 px-4 text-gray-600">简单的公开或私有访问控制</td>
                            <td class="py-3 px-4 text-gray-600">需要实现复杂的权限管理，如根据用户身份、时间、请求来源等条件进行细粒度的访问控制</td>
                        </tr>
                    </tbody>
                </table>
            </div>
        </section>

        <!-- Section 4 -->
        <section class="mb-16">
            <h2 class="section-title text-3xl font-bold" style="font-family: 'Noto Serif SC'">四、RAM 权限配置</h2>
            <p class="mb-6">
                RAM（Resource Access Management）是阿里云提供的一种身份与访问管理服务，它可以帮助用户集中管理用户（包括员工、合作伙伴和客户）、用户组以及权限。在 OSS 中，通过 RAM 权限配置可以实现对用户和用户组的精细访问控制。
            </p>
            
            <h3 class="font-bold text-xl mb-4 flex items-center">
                <i class="fas fa-users text-blue-500 mr-2"></i> RAM 的基本概念
            </h3>
            <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-8">
                <div class="bg-white p-5 rounded-lg shadow-sm">
                    <h4 class="font-bold text-lg text-blue-600 mb-2">用户</h4>
                    <p class="text-gray-700">RAM 用户是使用阿里云资源的实体，可以是公司员工、合作伙伴或客户等。</p>
                </div>
                <div class="bg-white p-5 rounded-lg shadow-sm">
                    <h4 class="font-bold text-lg text-blue-600 mb-2">用户组</h4>
                    <p class="text-gray-700">用户组是一组用户的集合，通过将用户添加到用户组中，可以方便地对一组用户进行统一的权限管理。</p>
                </div>
                <div class="bg-white p-5 rounded-lg shadow-sm">
                    <h4 class="font-bold text-lg text-blue-600 mb-2">权限策略</h4>
                    <p class="text-gray-700">权限策略是定义用户或用户组对阿里云资源访问权限的规则集合，可以是系统预设的策略，也可以是用户自定义的策略。</p>
                </div>
            </div>
            
            <h3 class="font-bold text-xl mb-4 flex items-center">
                <i class="fas fa-user-plus text-blue-500 mr-2"></i> 创建和管理 RAM 用户与权限
            </h3>
            <div class="mb-6">
                <h4 class="font-bold text-lg mb-2">1. 创建 RAM 用户</h4>
                <p class="text-gray-700 mb-4">
                    在 RAM 控制台中，可以创建新的用户，并为其分配访问密钥（AccessKey ID 和 AccessKey Secret）。这些密钥将用于用户在访问 OSS 等阿里云资源时进行身份验证。
                </p>
                
                <h4 class="font-bold text-lg mb-2">2. 创建用户组并添加用户</h4>
                <p class="text-gray-700 mb-4">
                    创建用户组后，将相关用户添加到用户组中，以便进行统一的权限管理。
                </p>
                
                <h4 class="font-bold text-lg mb-2">3. 配置权限策略</h4>
                <p class="text-gray-700 mb-4">
                    可以为用户组或单个用户关联权限策略。例如，创建一个自定义的权限策略，只允许用户对特定的 Bucket 进行读取操作：
                </p>
                
                <div class="code-block mb-6">
                    <div class="code-header">
                        <span>JSON</span>
                        <button class="copy-btn" onclick="copyCode(this)">
                            <i class="fas fa-copy mr-1"></i> 复制
                        </button>
                    </div>
                    <div class="code-content">
                        <pre class="text-gray-200"><code>{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "oss:GetObject"
      ],
      "Resource": "arn:acs:oss:{region}:{account-id}:ts/*"
    }
  ]
}</code></pre>
                    </div>
                </div>
                
                <p class="text-gray-700">
                    将这个权限策略关联到相应的用户组或用户后，该用户组或用户就只能对 "ts" Bucket 下的 Object 进行读取操作，而无法进行写入或删除等其他操作。
                </p>
            </div>
            
            <h3 class="font-bold text-xl mb-4 flex items-center">
                <i class="fas fa-project-diagram text-blue-500 mr-2"></i> RAM 与 OSS 访问控制的集成
            </h3>
            <p class="mb-6">
                通过 RAM 与 OSS 访问控制的集成，可以实现更加灵活和安全的权限管理。例如，在一个大型项目中，可能有多个不同角色的用户需要访问 OSS 资源，如开发人员、测试人员、运维人员等。通过 RAM 可以为每个角色创建相应的用户组，并为每个用户组配置不同的权限策略，从而确保每个角色只能访问其所需的 OSS 资源，提高了系统的安全性和可管理性。
            </p>
        </section>

        <!-- Section 5 -->
        <section class="mb-16">
            <h2 class="section-title text-3xl font-bold" style="font-family: 'Noto Serif SC'">五、综合运用 OSS 访问控制策略</h2>
            <p class="mb-6">
                在实际项目中，通常需要综合运用 Bucket Policy、ACL 和 RAM 权限配置来构建完善的 OSS 访问控制体系。
            </p>
            
            <h3 class="font-bold text-xl mb-4 flex items-center">
                <i class="fas fa-chalkboard-teacher text-blue-500 mr-2"></i> 场景示例
            </h3>
            <p class="mb-4">
                假设我们有一个在线教育平台，使用 OSS 存储课程视频、教学资料等资源。平台有不同类型的用户，包括教师、学生和管理员。
            </p>
            
            <div class="grid grid-cols-1 md:grid-cols-3 gap-6 mb-8">
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <div class="text-purple-500 text-3xl mb-4">
                        <i class="fas fa-user-tie"></i>
                    </div>
                    <h4 class="font-bold text-lg mb-2">教师</h4>
                    <p class="text-gray-600">需要能够上传和管理自己的课程资料，同时可以查看和下载其他教师共享的资料。</p>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <div class="text-green-500 text-3xl mb-4">
                        <i class="fas fa-user-graduate"></i>
                    </div>
                    <h4 class="font-bold text-lg mb-2">学生</h4>
                    <p class="text-gray-600">只能查看和下载教师发布的课程资料，不能进行上传和修改操作。</p>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <div class="text-red-500 text-3xl mb-4">
                        <i class="fas fa-user-shield"></i>
                    </div>
                    <h4 class="font-bold text-lg mb-2">管理员</h4>
                    <p class="text-gray-600">拥有对所有 OSS 资源的完全控制权限，包括创建和删除 Bucket、上传和删除 Object 等。</p>
                </div>
            </div>
            
            <h3 class="font-bold text-xl mb-4 flex items-center">
                <i class="fas fa-cogs text-blue-500 mr-2"></i> 访问控制策略设计
            </h3>
            
            <h4 class="font-bold text-lg mb-2">1. 使用 RAM 进行用户管理</h4>
            <p class="mb-4">
                创建教师用户组、学生用户组和管理员用户组，并为每个用户组添加相应的用户。
            </p>
            
            <h4 class="font-bold text-lg mb-2">2. 配置 RAM 权限策略</h4>
            <p class="mb-2">
                <strong>教师用户组权限策略</strong>：允许教师对自己所属课程的 Bucket 进行读取、写入和删除操作，同时允许读取其他教师共享的 Bucket：
            </p>
            
            <div class="code-block mb-6">
                <div class="code-header">
                    <span>JSON</span>
                    <button class="copy-btn" onclick="copyCode(this)">
                        <i class="fas fa-copy mr-1"></i> 复制
                    </button>
                </div>
                <div class="code-content">
                    <pre class="text-gray-200"><code>{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "oss:GetObject",
        "oss:PutObject",
        "oss:DeleteObject"
      ],
      "Resource": "arn:acs:oss:{region}:{account-id}:teacher-{teacher-id}/*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "oss:GetObject"
      ],
      "Resource": "arn:acs:oss:{region}:{account-id}:shared/*"
    }
  ]
}</code></pre>
                </div>
            </div>
            
            <p class="mb-2">
                <strong>学生用户组权限策略</strong>：只允许学生对课程资料的 Bucket 进行读取操作：
            </p>
            
            <div class="code-block mb-6">
                <div class="code-header">
                    <span>JSON</span>
                    <button class="copy-btn" onclick="copyCode(this)">
                        <i class="fas fa-copy mr-1"></i> 复制
                    </button>
                </div>
                <div class="code-content">
                    <pre class="text-gray-200"><code>{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "oss:GetObject"
      ],
      "Resource": "arn:acs:oss:{region}:{account-id}:course-materials/*"
    }
  ]
}</code></pre>
                </div>
            </div>
            
            <p class="mb-2">
                <strong>管理员用户组权限策略</strong>：具有完全 OSS 访问权限的策略：
            </p>
            
            <div class="code-block mb-6">
                <div class="code-header">
                    <span>JSON</span>
                    <button class="copy-btn" onclick="copyCode(this)">
                        <i class="fas fa-copy mr-1"></i> 复制
                    </button>
                </div>
                <div class="code-content">
                    <pre class="text-gray-200"><code>{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "oss:*"
      ],
      "Resource": "arn:acs:oss:{region}:{account-id}:*"
    }
  ]
}</code></pre>
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-sm note">
                <h4 class="font-bold text-lg mb-2">3. 使用 Bucket Policy 和 ACL 进行补充控制</h4>
                <p class="text-gray-700">
                    对于一些特殊的 Bucket，可以进一步使用 Bucket Policy 或 ACL 进行额外的访问控制。例如，对于一些敏感的课程资料 Bucket，可以设置其 ACL 为 "private"，并通过 Bucket Policy 来允许特定的教师或用户组进行访问。
                </p>
            </div>
        </section>

        <!-- Conclusion -->
        <section class="mb-16">
            <div class="bg-white p-8 rounded-xl shadow-md">
                <h2 class="text-2xl font-bold mb-4 flex items-center" style="font-family: 'Noto Serif SC'">
                    <i class="fas fa-check-circle text-green-500 mr-2"></i> 总结
                </h2>
                <p class="text-gray-700 mb-4">
                    OSS 访问控制策略是保障云存储数据安全的关键机制。通过合理组合使用 Bucket Policy、ACL 和 RAM 权限配置，可以实现从简单到复杂的各种访问控制需求，确保数据的安全性和可控性。
                </p>
                <div class="bg-blue-50 p-4 rounded-lg">
                    <h3 class="font-bold text-blue-600 mb-2">最佳实践建议：</h3>
                    <ul class="list-disc pl-5 space-y-2 text-gray-700">
                        <li>遵循最小权限原则，只授予用户完成工作所需的最小权限</li>
                        <li>优先使用 RAM 进行用户和权限管理，实现集中控制</li>
                        <li>对于复杂权限需求，使用 Bucket Policy 实现细粒度控制</li>
                        <li>谨慎使用 public-read-write 权限，避免数据安全风险</li>
                        <li>定期审查和优化访问控制策略</li>
                    </ul>
                </div>
            </div>
        </section>
    </div>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-8">
        <div class="container mx-auto px-6 max-w-5xl">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold text-white">技术小馆</h3>
                    <p class="text-gray-400">探索技术的无限可能</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-gray-300 hover:text-white transition duration-200 flex items-center">
                        <i class="fas fa-globe mr-2"></i> http://www.yuque.com/jtostring
                    </a>
                </div>
            </div>
            <div class="mt-6 pt-6 border-t border-gray-800 text-center text-gray-500 text-sm">
                &copy; 2023 技术小馆. 版权所有.
            </div>
        </div>
    </footer>

    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <script>
        // Initialize Mermaid
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
        
        // Copy code function
        function copyCode(button) {
            const codeBlock = button.closest('.code-block');
            const code = codeBlock.querySelector('code').innerText;
            navigator.clipboard.writeText(code).then(() => {
                const originalText = button.innerHTML;
                button.innerHTML = '<i class="fas fa-check mr-1"></i> 已复制';
                setTimeout(() => {
                    button.innerHTML = originalText;
                }, 2000);
            });
        }
    </script>
</body>
</html>
```